<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
                      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
    <title>Advanced Usage - Zend Framework Manual</title>

    <link href="../css/shCore.css" rel="stylesheet" type="text/css" />
    <link href="../css/shThemeDefault.css" rel="stylesheet" type="text/css" />
    <link href="../css/styles.css" media="all" rel="stylesheet" type="text/css" />
</head>
<body>
<h1>Zend Framework</h1>
<h2>Programmer's Reference Guide</h2>
<ul>
    <li><a href="../en/zend.session.advanced_usage.html">Inglês (English)</a></li>
    <li><a href="../pt-br/zend.session.advanced_usage.html">Português Brasileiro (Brazilian Portuguese)</a></li>
</ul>
<table width="100%">
    <tr valign="top">
        <td width="85%">
            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.session.basic_usage.html">Basic Usage</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.session.html">Zend_Session</a></span><br />
                        <span class="home"><a href="manual.html">Guia de Refer&ecirc;ncia do Programador</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.session.global_session_management.html">Global Session Management</a></div>
                    </td>
                </tr>
            </table>
<hr />
<div id="zend.session.advanced_usage" class="section"><div class="info"><h1 class="title">Advanced Usage</h1></div>
    

    <p class="para">
        While the basic usage examples are a perfectly acceptable way to utilize Zend Framework
        sessions, there are some best practices to consider. This section discusses the finer
        details of session handling and illustrates more advanced usage of the
        <span class="classname">Zend_Session</span> component.
    </p>

    <div class="section" id="zend.session.advanced_usage.starting_a_session"><div class="info"><h1 class="title">Starting a Session</h1></div>
        

        <p class="para">
            If you want all requests to have a session facilitated by
            <span class="classname">Zend_Session</span>, then start the session in the bootstrap file:
        </p>

        <div class="example" id="zend.session.advanced_usage.starting_a_session.example"><div class="info"><p><b>Example #1 Starting the Global Session</b></p></div>
            

            <pre class="programlisting brush: php">
Zend_Session::start();
</pre>

        </div>

        <p class="para">
            By starting the session in the bootstrap file, you avoid the possibility that your
            session might be started after headers have been sent to the browser, which results in
            an exception, and possibly a broken page for website viewers. Various advanced features
            require  <span class="methodname">Zend_Session::start()</span> first. (More on advanced features
            later.)
        </p>

        <p class="para">
            There are four ways to start a session, when using <span class="classname">Zend_Session</span>.
            Two are wrong.
        </p>

        <ol type="1">
            <li class="listitem">
                <p class="para">
                    Wrong: Do not enable <acronym class="acronym">PHP</acronym>&#039;s <a href="http://www.php.net/manual/en/ref.session.php#ini.session.auto-start" class="link external">&raquo; 
                        <code class="code">session.auto_start</code> setting</a>. If you do not have the
                    ability to disable this setting in php.ini, you are using mod_php (or
                    equivalent), and the setting is already enabled in <code class="code">php.ini</code>, then
                    add the following to your <code class="code">.htaccess</code> file (usually in your
                    <acronym class="acronym">HTML</acronym> document root directory):
                </p>

                <pre class="programlisting brush: httpd.conf">
php_value session.auto_start 0
</pre>

            </li>

            <li class="listitem">
                <p class="para">
                    Wrong: Do not use <acronym class="acronym">PHP</acronym>&#039;s <a href="http://www.php.net/session_start" class="link external">&raquo;  <span class="methodname">session_start()</span></a>
                    function directly. If you use  <span class="methodname">session_start()</span> directly,
                    and then start using <span class="classname">Zend_Session_Namespace</span>, an exception
                    will be thrown by  <span class="methodname">Zend_Session::start()</span> (&quot;session has
                    already been started&quot;). If you call  <span class="methodname">session_start()</span>
                    after using <span class="classname">Zend_Session_Namespace</span> or calling
                     <span class="methodname">Zend_Session::start()</span>, an error of level
                    <b><tt>E_NOTICE</tt></b> will be generated, and the call will be ignored.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    Correct: Use  <span class="methodname">Zend_Session::start()</span>. If you want all
                    requests to have and use sessions, then place this function call early and
                    unconditionally in your bootstrap code. Sessions have some overhead. If some
                    requests need sessions, but other requests will not need to use sessions, then:
                </p>

                <ul class="itemizedlist">
                    <li class="listitem">
                        <p class="para">
                            Unconditionally set the <code class="code">strict</code> option to
                            <b><tt>TRUE</tt></b> using
                             <span class="methodname">Zend_Session::setOptions()</span> in your bootstrap.
                        </p>
                    </li>

                    <li class="listitem">
                        <p class="para">
                            Call  <span class="methodname">Zend_Session::start()</span> only for requests
                            that need to use sessions and before any
                            <span class="classname">Zend_Session_Namespace</span> objects are instantiated.
                        </p>
                    </li>

                    <li class="listitem">
                        <p class="para">
                            Use &quot;<code class="code">new Zend_Session_Namespace()</code>&quot; normally, where needed,
                            but make sure  <span class="methodname">Zend_Session::start()</span> has been
                            called previously.
                        </p>
                    </li>
                </ul>

                <p class="para">
                    The <code class="code">strict</code> option prevents
                    <code class="code">new Zend_Session_Namespace()</code> from automatically starting the
                    session using  <span class="methodname">Zend_Session::start()</span>. Thus, this option
                    helps application developers enforce a design decision to avoid using sessions
                    for certain requests, since it causes an exception to be thrown when
                    <span class="classname">Zend_Session_Namespace</span> is instantiated before
                     <span class="methodname">Zend_Session::start()</span> is called. Developers should
                    carefully consider the impact of using
                     <span class="methodname">Zend_Session::setOptions()</span>, since these options have
                    global effect, owing to their correspondence to the underlying options for
                    ext/session.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    Correct: Just instantiate <span class="classname">Zend_Session_Namespace</span> whenever
                    needed, and the underlying <acronym class="acronym">PHP</acronym> session will be automatically
                    started. This offers extremely simple usage that works well in most situations.
                    However, you then become responsible for ensuring that the first
                    <code class="code">new Zend_Session_Namespace()</code> happens <em class="emphasis">before</em>
                    any output (e.g., <a href="http://www.php.net/headers_sent" class="link external">&raquo; HTTP
                        headers</a>) has been sent by <acronym class="acronym">PHP</acronym> to the client, if
                    you are using the default, cookie-based sessions (strongly recommended). See
                    <a href="zend.session.global_session_management.html#zend.session.global_session_management.headers_sent" class="link">this
                        section</a> for more information.
                </p>
            </li>
        </ol>
    </div>

    <div class="section" id="zend.session.advanced_usage.locking"><div class="info"><h1 class="title">Locking Session Namespaces</h1></div>
        

        <p class="para">
            Session namespaces can be locked, to prevent further alterations to the data in that
            namespace. Use  <span class="methodname">lock()</span> to make a specific namespace read-only,
             <span class="methodname">unLock()</span> to make a read-only namespace read-write, and
             <span class="methodname">isLocked()</span> to test if a namespace has been previously locked.
            Locks are transient and do not persist from one request to the next. Locking the
            namespace has no effect on setter methods of objects stored in the namespace, but does
            prevent the use of the namespace&#039;s setter method to remove or replace objects stored
            directly in the namespace. Similarly, locking
            <span class="classname">Zend_Session_Namespace</span> instances does not prevent the use of
            symbol table aliases to the same data (see <a href="http://www.php.net/references" class="link external">&raquo; PHP references</a>).
        </p>

        <div class="example" id="zend.session.advanced_usage.locking.example.basic"><div class="info"><p><b>Example #2 Locking Session Namespaces</b></p></div>
            

            <pre class="programlisting brush: php">
$userProfileNamespace = new Zend_Session_Namespace(&#039;userProfileNamespace&#039;);

// marking session as read only locked
$userProfileNamespace-&gt;lock();

// unlocking read-only lock
if ($userProfileNamespace-&gt;isLocked()) {
    $userProfileNamespace-&gt;unLock();
}
</pre>

        </div>
    </div>

    <div class="section" id="zend.session.advanced_usage.expiration"><div class="info"><h1 class="title">Namespace Expiration</h1></div>
        

        <p class="para">
            Limits can be placed on the longevity of both namespaces and individual keys in
            namespaces. Common use cases include passing temporary information between requests, and
            reducing exposure to certain security risks by removing access to potentially sensitive
            information some time after authentication occurred. Expiration can be based on either
            elapsed seconds or the number of &quot;hops&quot;, where a hop occurs for each successive request.
        </p>

        <div class="example" id="zend.session.advanced_usage.expiration.example"><div class="info"><p><b>Example #3 Expiration Examples</b></p></div>
            

            <pre class="programlisting brush: php">
$s = new Zend_Session_Namespace(&#039;expireAll&#039;);
$s-&gt;a = &#039;apple&#039;;
$s-&gt;p = &#039;pear&#039;;
$s-&gt;o = &#039;orange&#039;;

$s-&gt;setExpirationSeconds(5, &#039;a&#039;); // expire only the key &quot;a&quot; in 5 seconds

// expire entire namespace in 5 &quot;hops&quot;
$s-&gt;setExpirationHops(5);

$s-&gt;setExpirationSeconds(60);
// The &quot;expireAll&quot; namespace will be marked &quot;expired&quot; on
// the first request received after 60 seconds have elapsed,
// or in 5 hops, whichever happens first.
</pre>

        </div>

        <p class="para">
            When working with data expiring from the session in the current request, care should be
            used when retrieving them. Although the data are returned by reference, modifying the
            data will not make expiring data persist past the current request. In order to &quot;reset&quot;
            the expiration time, fetch the data into temporary variables, use the namespace to unset
            them, and then set the appropriate keys again.
        </p>
    </div>

    <div class="section" id="zend.session.advanced_usage.controllers"><div class="info"><h1 class="title">Session Encapsulation and Controllers</h1></div>
        

        <p class="para">
            Namespaces can also be used to separate session access by controllers to protect
            variables from contamination. For example, an authentication controller might keep its
            session state data separate from all other controllers for meeting security
            requirements.
        </p>

        <div class="example" id="zend.session.advanced_usage.controllers.example"><div class="info"><p><b>Example #4 Namespaced Sessions for Controllers with Automatic Expiration</b></p></div>
            

            <div class="example-contents"><p>
                The following code, as part of a controller that displays a test question, initiates
                a boolean variable to represent whether or not a submitted answer to the test
                question should be accepted. In this case, the application user is given 300 seconds
                to answer the displayed question.
            </p></div>

            <pre class="programlisting brush: php">
// ...
// in the question view controller
$testSpace = new Zend_Session_Namespace(&#039;testSpace&#039;);
// expire only this variable
$testSpace-&gt;setExpirationSeconds(300, &#039;accept_answer&#039;);
$testSpace-&gt;accept_answer = true;
//...
</pre>


            <div class="example-contents"><p>
                Below, the controller that processes the answers to test questions determines
                whether or not to accept an answer based on whether the user submitted the answer
                within the allotted time:
            </p></div>

            <pre class="programlisting brush: php">
// ...
// in the answer processing controller
$testSpace = new Zend_Session_Namespace(&#039;testSpace&#039;);
if ($testSpace-&gt;accept_answer === true) {
    // within time
}
else {
    // not within time
}
// ...
</pre>

        </div>
    </div>

    <div class="section" id="zend.session.advanced_usage.single_instance"><div class="info"><h1 class="title">Preventing Multiple Instances per Namespace</h1></div>
        

        <p class="para">
            Although <a href="zend.session.advanced_usage.html#zend.session.advanced_usage.locking" class="link">session locking</a>
            provides a good degree of protection against unintended use of namespaced session data,
            <span class="classname">Zend_Session_Namespace</span> also features the ability to prevent the
            creation of multiple instances corresponding to a single namespace.
        </p>

        <p class="para">
            To enable this behavior, pass <b><tt>TRUE</tt></b> to the second constructor
            argument when creating the last allowed instance of
            <span class="classname">Zend_Session_Namespace</span>. Any subsequent attempt to instantiate the
            same namespace would result in a thrown exception.
        </p>

        <div class="example" id="zend.session.advanced_usage.single_instance.example"><div class="info"><p><b>Example #5 Limiting Session Namespace Access to a Single Instance</b></p></div>
            

            <pre class="programlisting brush: php">
// create an instance of a namespace
$authSpaceAccessor1 = new Zend_Session_Namespace(&#039;Zend_Auth&#039;);

// create another instance of the same namespace, but disallow any
// new instances
$authSpaceAccessor2 = new Zend_Session_Namespace(&#039;Zend_Auth&#039;, true);

// making a reference is still possible
$authSpaceAccessor3 = $authSpaceAccessor2;

$authSpaceAccessor1-&gt;foo = &#039;bar&#039;;

assert($authSpaceAccessor2-&gt;foo, &#039;bar&#039;);

try {
    $aNamespaceObject = new Zend_Session_Namespace(&#039;Zend_Auth&#039;);
} catch (Zend_Session_Exception $e) {
    echo &#039;Cannot instantiate this namespace since &#039; .
         &#039;$authSpaceAccessor2 was created\n&#039;;
}
</pre>

        </div>

        <p class="para">
            The second parameter in the constructor above tells
            <span class="classname">Zend_Session_Namespace</span> that any future instances with the
            &quot;<span class="classname">Zend_Auth</span>&quot; namespace are not allowed. Attempting to create such
            an instance causes an exception to be thrown by the constructor. The developer therefore
            becomes responsible for storing a reference to an instance object
            (<var class="varname">$authSpaceAccessor1</var>, <var class="varname">$authSpaceAccessor2</var>, or
            <var class="varname">$authSpaceAccessor3</var> in the example above) somewhere, if access to the
            session namespace is needed at a later time during the same request. For example, a
            developer may store the reference in a static variable, add the reference to a <a href="http://www.martinfowler.com/eaaCatalog/registry.html" class="link external">&raquo; registry</a> (see
            <a href="zend.registry.html" class="link">Zend_Registry</a>), or otherwise make it available to
            other methods that may need access to the session namespace.
        </p>
    </div>

    <div class="section" id="zend.session.advanced_usage.arrays"><div class="info"><h1 class="title">Working with Arrays</h1></div>
        

        <p class="para">
            Due to the implementation history of <acronym class="acronym">PHP</acronym> magic methods, modifying an
            array inside a namespace may not work under <acronym class="acronym">PHP</acronym> versions before
            5.2.1. If you will only be working with <acronym class="acronym">PHP</acronym> 5.2.1 or later, then you
            may <a href="zend.session.advanced_usage.html#zend.session.advanced_usage.objects" class="link">skip to the next section</a>.
        </p>

        <div class="example" id="zend.session.advanced_usage.arrays.example.modifying"><div class="info"><p><b>Example #6 Modifying Array Data with a Session Namespace</b></p></div>
            

            <div class="example-contents"><p>
                The following illustrates how the problem may be reproduced:
            </p></div>

            <pre class="programlisting brush: php">
$sessionNamespace = new Zend_Session_Namespace();
$sessionNamespace-&gt;array = array();

// may not work as expected before PHP 5.2.1
$sessionNamespace-&gt;array[&#039;testKey&#039;] = 1;
echo $sessionNamespace-&gt;array[&#039;testKey&#039;];
</pre>

        </div>

        <div class="example" id="zend.session.advanced_usage.arrays.example.building_prior"><div class="info"><p><b>Example #7 Building Arrays Prior to Session Storage</b></p></div>
            

            <div class="example-contents"><p>
                If possible, avoid the problem altogether by storing arrays into a session namespace
                only after all desired array values have been set.
            </p></div>

            <pre class="programlisting brush: php">
$sessionNamespace = new Zend_Session_Namespace(&#039;Foo&#039;);
$sessionNamespace-&gt;array = array(&#039;a&#039;, &#039;b&#039;, &#039;c&#039;);
</pre>

        </div>

        <p class="para">
            If you are using an affected version of <acronym class="acronym">PHP</acronym> and need to modify the
            array after assigning it to a session namespace key, you may use either or both of the
            following workarounds.
        </p>

        <div class="example" id="zend.session.advanced_usage.arrays.example.workaround.reassign"><div class="info"><p><b>Example #8 Workaround: Reassign a Modified Array</b></p></div>
            

            <div class="example-contents"><p>
                In the code that follows, a copy of the stored array is created, modified, and
                reassigned to the location from which the copy was created, overwriting the original
                array.
            </p></div>

            <pre class="programlisting brush: php">
$sessionNamespace = new Zend_Session_Namespace();

// assign the initial array
$sessionNamespace-&gt;array = array(&#039;tree&#039; =&gt; &#039;apple&#039;);

// make a copy of the array
$tmp = $sessionNamespace-&gt;array;

// modfiy the array copy
$tmp[&#039;fruit&#039;] = &#039;peach&#039;;

// assign a copy of the array back to the session namespace
$sessionNamespace-&gt;array = $tmp;

echo $sessionNamespace-&gt;array[&#039;fruit&#039;]; // prints &quot;peach&quot;
</pre>

        </div>

        <div class="example" id="zend.session.advanced_usage.arrays.example.workaround.reference"><div class="info"><p><b>Example #9 Workaround: store array containing reference</b></p></div>
            

            <div class="example-contents"><p>
                Alternatively, store an array containing a reference to the desired array, and then
                access it indirectly.
            </p></div>

            <pre class="programlisting brush: php">
$myNamespace = new Zend_Session_Namespace(&#039;myNamespace&#039;);
$a = array(1, 2, 3);
$myNamespace-&gt;someArray = array( &amp;$a );
$a[&#039;foo&#039;] = &#039;bar&#039;;
echo $myNamespace-&gt;someArray[&#039;foo&#039;]; // prints &quot;bar&quot;
</pre>

        </div>
    </div>

    <div class="section" id="zend.session.advanced_usage.objects"><div class="info"><h1 class="title">Using Sessions with Objects</h1></div>
        

        <p class="para">
            If you plan to persist objects in the <acronym class="acronym">PHP</acronym> session, know that they
            will be <a href="http://www.php.net/manual/en/language.oop.serialization.php" class="link external">&raquo; serialized</a>
            for storage. Thus, any object persisted with the <acronym class="acronym">PHP</acronym> session must be
            unserialized upon retrieval from storage. The implication is that the developer must
            ensure that the classes for the persisted objects must have been defined before the
            object is unserialized from session storage. If an unserialized object&#039;s class is not
            defined, then it becomes an instance of <code class="code">stdClass</code>.
        </p>
    </div>

    <div class="section" id="zend.session.advanced_usage.testing"><div class="info"><h1 class="title">Using Sessions with Unit Tests</h1></div>
        

        <p class="para">
            Zend Framework relies on PHPUnit to facilitate testing of itself. Many developers extend
            the existing suite of unit tests to cover the code in their applications. The exception
            &quot;<em class="emphasis">Zend_Session is currently marked as read-only</em>&quot; is thrown while
            performing unit tests, if any write-related methods are used after ending the session.
            However, unit tests using <span class="classname">Zend_Session</span> require extra attention,
            because closing ( <span class="methodname">Zend_Session::writeClose()</span>), or destroying a
            session ( <span class="methodname">Zend_Session::destroy()</span>) prevents any further setting
            or unsetting of keys in any instance of <span class="classname">Zend_Session_Namespace</span>.
            This behavior is a direct result of the underlying ext/session mechanism and
            <acronym class="acronym">PHP</acronym>&#039;s  <span class="methodname">session_destroy()</span> and
             <span class="methodname">session_write_close()</span>, which have no &quot;undo&quot; mechanism to
            facilitate setup/teardown with unit tests.
        </p>

        <p class="para">
            To work around this, see the unit test
             <span class="methodname">testSetExpirationSeconds()</span> in <code class="code">SessionTest.php</code> and
            <code class="code">SessionTestHelper.php</code>, both located in <code class="code">tests/Zend/Session</code>,
            which make use of <acronym class="acronym">PHP</acronym>&#039;s  <span class="methodname">exec()</span> to launch a
            separate process. The new process more accurately simulates a second, successive request
            from a browser. The separate process begins with a &quot;clean&quot; session, just like any
            <acronym class="acronym">PHP</acronym> script execution for a web request. Also, any changes to
            <var class="varname">$_SESSION</var> made in the calling process become available to the child
            process, provided the parent closed the session before using
             <span class="methodname">exec()</span>.
        </p>

        <div class="example" id="zend.session.advanced_usage.testing.example"><div class="info"><p><b>Example #10 PHPUnit Testing Code Dependent on Zend_Session</b></p></div>
            

            <pre class="programlisting brush: php">
// testing setExpirationSeconds()
$script = &#039;SessionTestHelper.php&#039;;
$s = new Zend_Session_Namespace(&#039;space&#039;);
$s-&gt;a = &#039;apple&#039;;
$s-&gt;o = &#039;orange&#039;;
$s-&gt;setExpirationSeconds(5);

Zend_Session::regenerateId();
$id = Zend_Session::getId();
session_write_close(); // release session so process below can use it
sleep(4); // not long enough for things to expire
exec($script . &quot;expireAll $id expireAll&quot;, $result);
$result = $this-&gt;sortResult($result);
$expect = &#039;;a === apple;o === orange;p === pear&#039;;
$this-&gt;assertTrue($result === $expect,
    &quot;iteration over default Zend_Session namespace failed; &quot; .
    &quot;expecting result === &#039;$expect&#039;, but got &#039;$result&#039;&quot;);

sleep(2); // long enough for things to expire (total of 6 seconds
          // waiting, but expires in 5)
exec($script . &quot;expireAll $id expireAll&quot;, $result);
$result = array_pop($result);
$this-&gt;assertTrue($result === &#039;&#039;,
    &quot;iteration over default Zend_Session namespace failed; &quot; .
    &quot;expecting result === &#039;&#039;, but got &#039;$result&#039;)&quot;);
session_start(); // resume artificially suspended session

// We could split this into a separate test, but actually, if anything
// leftover from above contaminates the tests below, that is also a
// bug that we want to know about.
$s = new Zend_Session_Namespace(&#039;expireGuava&#039;);
$s-&gt;setExpirationSeconds(5, &#039;g&#039;); // now try to expire only 1 of the
                                  // keys in the namespace
$s-&gt;g = &#039;guava&#039;;
$s-&gt;p = &#039;peach&#039;;
$s-&gt;p = &#039;plum&#039;;

session_write_close(); // release session so process below can use it
sleep(6); // not long enough for things to expire
exec($script . &quot;expireAll $id expireGuava&quot;, $result);
$result = $this-&gt;sortResult($result);
session_start(); // resume artificially suspended session
$this-&gt;assertTrue($result === &#039;;p === plum&#039;,
    &quot;iteration over named Zend_Session namespace failed (result=$result)&quot;);
</pre>

        </div>
    </div>
</div>
        <hr />

            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.session.basic_usage.html">Basic Usage</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.session.html">Zend_Session</a></span><br />
                        <span class="home"><a href="manual.html">Guia de Refer&ecirc;ncia do Programador</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.session.global_session_management.html">Global Session Management</a></div>
                    </td>
                </tr>
            </table>
</td>
        <td style="font-size: smaller;" width="15%"> <style type="text/css">
#leftbar {
	float: left;
	width: 186px;
	padding: 5px;
	font-size: smaller;
}
ul.toc {
	margin: 0px 5px 5px 5px;
	padding: 0px;
}
ul.toc li {
	font-size: 85%;
	margin: 1px 0 1px 1px;
	padding: 1px 0 1px 11px;
	list-style-type: none;
	background-repeat: no-repeat;
	background-position: center left;
}
ul.toc li.header {
	font-size: 115%;
	padding: 5px 0px 5px 11px;
	border-bottom: 1px solid #cccccc;
	margin-bottom: 5px;
}
ul.toc li.active {
	font-weight: bold;
}
ul.toc li a {
	text-decoration: none;
}
ul.toc li a:hover {
	text-decoration: underline;
}
</style>
 <ul class="toc">
  <li class="header home"><a href="manual.html">Guia de Refer&ecirc;ncia do Programador</a></li>
  <li class="header up"><a href="manual.html">Guia de Refer&ecirc;ncia do Programador</a></li>
  <li class="header up"><a href="reference.html">Refer&ecirc;ncia do Zend Framework</a></li>
  <li class="header up"><a href="zend.session.html">Zend_Session</a></li>
  <li><a href="zend.session.introduction.html">Introduction</a></li>
  <li><a href="zend.session.basic_usage.html">Basic Usage</a></li>
  <li class="active"><a href="zend.session.advanced_usage.html">Advanced Usage</a></li>
  <li><a href="zend.session.global_session_management.html">Global Session Management</a></li>
  <li><a href="zend.session.savehandler.dbtable.html">Zend_Session_SaveHandler_DbTable</a></li>
 </ul>
 </td>
    </tr>
</table>

<script type="text/javascript" src="../js/shCore.js"></script>
<script type="text/javascript" src="../js/shAutoloader.js"></script>
<script type="text/javascript" src="../js/main.js"></script>

</body>
</html>